sig module type Graph = Graph val create : (module Bap.Std.Graphlib.Graph with type t = 'c and type Edge.label = 'b and type Node.label = 'a) -> ?nodes:'a list -> ?edges:('a * 'a * 'b) list -> unit -> 'c val to_dot : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?graph_attrs:('c -> Bap.Std.graph_attr list) -> ?node_attrs:('n -> Bap.Std.node_attr list) -> ?edge_attrs:('e -> Bap.Std.edge_attr list) -> ?string_of_node:('n -> string) -> ?string_of_edge:('e -> string) -> ?channel:Pervasives.out_channel -> ?formatter:Format.formatter -> ?filename:string -> 'c -> unit val depth_first_search : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?rev:bool -> ?start:'n -> ?start_tree:('n -> 's -> 's) -> ?enter_node:(int -> 'n -> 's -> 's) -> ?leave_node:(int -> 'n -> 's -> 's) -> ?enter_edge:(Bap.Std.edge_kind -> 'e -> 's -> 's) -> ?leave_edge:(Bap.Std.edge_kind -> 'e -> 's -> 's) -> 'c -> init:'s -> 's val depth_first_visit : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?rev:bool -> ?start:'n -> 'c -> init:'s -> ('n, 'e, 's) Bap.Std.dfs_visitor -> 's class ['n, 'e, 's] dfs_identity_visitor : ['n, 'e, 's] dfs_visitor val reverse_postorder_traverse : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?rev:bool -> ?start:'n -> 'c -> 'n Bap.Std.seq val postorder_traverse : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?rev:bool -> ?start:'n -> 'c -> 'n Bap.Std.seq val dominators : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?rev:bool -> 'c -> 'n -> 'n Bap.Std.tree val dom_frontier : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?rev:bool -> 'c -> 'n Bap.Std.tree -> 'n Bap.Std.frontier val strong_components : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> 'c -> 'n Bap.Std.partition val shortest_path : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?weight:('e -> int) -> ?rev:bool -> 'c -> 'n -> 'n -> 'e Bap.Std.path option val is_reachable : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?rev:bool -> 'c -> 'n -> 'n -> bool val fold_reachable : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?rev:bool -> init:'a -> f:('a -> 'n -> 'a) -> 'c -> 'n -> 'a val compare : (module Bap.Std.Graphlib.Graph with type node = 'n and type t = 'a) -> (module Bap.Std.Graphlib.Graph with type node = 'n and type t = 'b) -> 'a -> 'b -> int val filtered : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) -> ?skip_node:('n -> bool) -> ?skip_edge:('e -> bool) -> unit -> (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c) val view : (module Bap.Std.Graphlib.Graph with type edge = 'e and type node = 'n and type t = 'c and type Edge.label = 'b and type Node.label = 'a) -> node:('n -> 'f) * ('f -> 'n) -> edge:('e -> 'd) * ('d -> 'e) -> node_label:('a -> 'p) * ('p -> 'a) -> edge_label:('b -> 'r) * ('r -> 'b) -> (module Bap.Std.Graphlib.Graph with type edge = 'd and type node = 'f and type t = 'c and type Edge.label = 'r and type Node.label = 'p) module To_ocamlgraph : functor (G : Graph) -> sig type t = G.t module V : sig type t = G.node val compare : t -> t -> int val hash : t -> int val equal : t -> t -> bool type label = G.Node.label val create : label -> t val label : t -> label end type vertex = V.t module E : sig type t = G.edge val compare : t -> t -> int type vertex = vertex val src : t -> vertex val dst : t -> vertex type label = G.Edge.label val create : vertex -> label -> vertex -> t val label : t -> label end type edge = E.t val is_directed : bool val is_empty : t -> bool val nb_vertex : t -> int val nb_edges : t -> int val out_degree : t -> vertex -> int val in_degree : t -> vertex -> int val mem_vertex : t -> vertex -> bool val mem_edge : t -> vertex -> vertex -> bool val mem_edge_e : t -> edge -> bool val find_edge : t -> vertex -> vertex -> edge val find_all_edges : t -> vertex -> vertex -> edge list val succ : t -> vertex -> vertex list val pred : t -> vertex -> vertex list val succ_e : t -> vertex -> edge list val pred_e : t -> vertex -> edge list val iter_vertex : (vertex -> unit) -> t -> unit val fold_vertex : (vertex -> 'a -> 'a) -> t -> 'a -> 'a val iter_edges : (vertex -> vertex -> unit) -> t -> unit val fold_edges : (vertex -> vertex -> 'a -> 'a) -> t -> 'a -> 'a val iter_edges_e : (edge -> unit) -> t -> unit val fold_edges_e : (edge -> 'a -> 'a) -> t -> 'a -> 'a val map_vertex : (vertex -> vertex) -> t -> t val iter_succ : (vertex -> unit) -> t -> vertex -> unit val iter_pred : (vertex -> unit) -> t -> vertex -> unit val fold_succ : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a val fold_pred : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a val iter_succ_e : (edge -> unit) -> t -> vertex -> unit val fold_succ_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a val iter_pred_e : (edge -> unit) -> t -> vertex -> unit val fold_pred_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a val empty : t val add_vertex : t -> vertex -> t val remove_vertex : t -> vertex -> t val add_edge : t -> vertex -> vertex -> t val add_edge_e : t -> edge -> t val remove_edge : t -> vertex -> vertex -> t val remove_edge_e : t -> edge -> t end module Of_ocamlgraph : functor (G : Graph.Sig.P) -> sig type t = G.t type node = G.V.t type edge = G.E.t module Node : sig type t = node type graph = t type label = G.V.label type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = G.E.label val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Filtered : functor (G : Graph) (P : sig type edge = G.edge type node = G.node val edge : edge -> bool val node : node -> bool end) -> sig type t = G.t type node = G.node type edge = G.edge module Node : sig type t = G.node type graph = G.t type label = G.Node.label type edge = G.edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness = G.Node.comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t = 'a G.Node.Hash_queue.t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = G.edge type node = G.node type graph = G.t type label = G.Edge.label val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness = G.Edge.comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t = 'a G.Edge.Hash_queue.t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Mapper : functor (G : Graph) (N : sig type s = G.node type t val forward : s -> t val backward : t -> s end) (E : sig type s = G.edge type t val forward : s -> t val backward : t -> s end) (NL : sig type s = G.Node.label type t val forward : s -> t val backward : t -> s end) (EL : sig type s = G.Edge.label type t val forward : s -> t val backward : t -> s end) -> sig type t = G.t type node = N.t type edge = E.t module Node : sig type t = node type graph = t type label = NL.t type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = EL.t val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Make : functor (Node : Opaque) (Edge : Opaque) -> sig type t type node = Node.t type edge module Node : sig type t = node type graph = t type label = Node.t type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = Edge.t val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module type Graphs = sig type node module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Char : sig type node = char module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Int : sig type node = int module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Word : sig type node = word module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Type : sig type node = typ module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Value : sig type node = value module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module String : sig type node = string module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Var : sig type node = var module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Exp : sig type node = exp module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Stmt : sig type node = stmt module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Tid : sig type node = tid module Bool : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = bool val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Char : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = char val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Unit : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = unit val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Value : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = value val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Word : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = word val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Int : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = int val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module String : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = string val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Exp : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = exp val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Stmt : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = stmt val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Var : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = var val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tid : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = tid val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Type : sig type t type node = node type edge module Node : sig type t = node type graph = t type label = node type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end module Edge : sig type t = edge type node = node type graph = t type label = typ val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end module Ir : sig type t type edge type node module Edge : sig type t = edge type node = node type graph = t type label val create : node -> node -> label -> t val label : t -> label val src : t -> node val dst : t -> node val mem : t -> graph -> bool val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val jmps : [ `after | `before ] -> Bap.Std.Graphlib.Ir.t -> Bap.Std.graph -> Bap.Std.jmp Bap.Std.term Bap.Std.seq val edges : [ `after | `before ] -> Bap.Std.Graphlib.Ir.t -> Bap.Std.graph -> Bap.Std.Graphlib.Ir.t Bap.Std.seq val jmp : Bap.Std.Graphlib.Ir.t -> Bap.Std.jmp Bap.Std.term val tid : Bap.Std.Graphlib.Ir.t -> Bap.Std.tid val cond : Bap.Std.Graphlib.Ir.t -> Bap.Std.graph -> Bap.Std.exp val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Node : sig type t = node type graph = t type label = blk term type edge = edge val create : label -> t val label : t -> label val mem : t -> graph -> bool val succs : t -> graph -> t seq val preds : t -> graph -> t seq val inputs : t -> graph -> edge seq val outputs : t -> graph -> edge seq val degree : ?dir:[ `In | `Out ] -> t -> graph -> int val insert : t -> graph -> graph val update : t -> label -> graph -> graph val remove : t -> graph -> graph val has_edge : t -> t -> graph -> bool val edge : t -> t -> graph -> edge option val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end val empty : t val nodes : t -> node seq val edges : t -> edge seq val is_directed : bool val number_of_edges : t -> int val number_of_nodes : t -> int val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val min : t -> t -> t val max : t -> t -> t val ascending : t -> t -> int val descending : t -> t -> int val between : t -> low:t -> high:t -> bool module Replace_polymorphic_compare : sig val ( >= ) : t -> t -> bool val ( <= ) : t -> t -> bool val ( = ) : t -> t -> bool val ( > ) : t -> t -> bool val ( < ) : t -> t -> bool val ( <> ) : t -> t -> bool val equal : t -> t -> bool val compare : t -> t -> int val min : t -> t -> t val max : t -> t -> t val _squelch_unused_module_warning_ : unit end type comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val validate_lbound : min:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_ubound : max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check val validate_bound : min:t Core_kernel.Comparable_intf.bound -> max:t Core_kernel.Comparable_intf.bound -> t Core_kernel.Validate.check module Map : sig module Key : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator end module Tree : sig type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.Tree.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t end type 'a t = (Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t val empty : 'a t val singleton : Key.t -> 'a -> 'a t val of_alist : (Key.t * 'a) list -> [ `Duplicate_key of Key.t | `Ok of 'a t ] val of_alist_or_error : (Key.t * 'a) list -> 'a t Core_kernel.Or_error.t val of_alist_exn : (Key.t * 'a) list -> 'a t val of_alist_multi : (Key.t * 'a) list -> 'a list t val of_alist_fold : (Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t val of_alist_reduce : (Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t val of_sorted_array : (Key.t * 'a) array -> 'a t Core_kernel.Or_error.t val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t val of_tree : 'a Tree.t -> 'a t val invariants : 'a t -> bool val is_empty : 'a t -> bool val length : 'a t -> int val add : 'a t -> key:Key.t -> data:'a -> 'a t val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t val find : 'a t -> Key.t -> 'a option val find_exn : 'a t -> Key.t -> 'a val remove : 'a t -> Key.t -> 'a t val mem : 'a t -> Key.t -> bool val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val iter2 : 'a t -> 'b t -> f:(key:Key.t -> data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> unit) -> unit val map : 'a t -> f:('a -> 'b) -> 'b t val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t val fold : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val fold_right : 'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t val filter_map : 'a t -> f:('a -> 'b option) -> 'b t val filter_mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool val keys : 'a t -> Key.t list val data : 'a t -> 'a list val to_alist : 'a t -> (Key.t * 'a) list val validate : name:(Key.t -> string) -> 'a Core_kernel.Validate.check -> 'a t Core_kernel.Validate.check val merge : 'a t -> 'b t -> f:(key:Key.t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> 'c t val symmetric_diff : 'a t -> 'a t -> data_equal:('a -> 'a -> bool) -> (Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ]) Core_kernel.Sequence.t val min_elt : 'a t -> (Key.t * 'a) option val min_elt_exn : 'a t -> Key.t * 'a val max_elt : 'a t -> (Key.t * 'a) option val max_elt_exn : 'a t -> Key.t * 'a val for_all : 'a t -> f:('a -> bool) -> bool val exists : 'a t -> f:('a -> bool) -> bool val fold_range_inclusive : 'a t -> min:Key.t -> max:Key.t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b val range_to_alist : 'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list val prev_key : 'a t -> Key.t -> (Key.t * 'a) option val next_key : 'a t -> Key.t -> (Key.t * 'a) option val nth : 'a t -> int -> (Key.t * 'a) option val rank : 'a t -> Key.t -> int option val to_tree : 'a t -> 'a Tree.t val to_sequence : ?keys_in:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Key.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Key.t ] -> 'a t -> (Key.t * 'a) Core_kernel.Sequence.t val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t val sexp_of_t : ('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int end module Set : sig module Elt : sig type t = t type comparator_witness = comparator_witness val comparator : (t, comparator_witness) Core_kernel.Comparator.comparator val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Tree : sig type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.Tree.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.Tree.t -> f:('a -> Elt.t option) -> t val of_tree : t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t val length : t -> int val is_empty : t -> bool val iter : t -> f:(Elt.t -> unit) -> unit val fold : t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum val exists : t -> f:(Elt.t -> bool) -> bool val for_all : t -> f:(Elt.t -> bool) -> bool val count : t -> f:(Elt.t -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> t -> f:(Elt.t -> 'sum) -> 'sum val find : t -> f:(Elt.t -> bool) -> Elt.t option val find_map : t -> f:(Elt.t -> 'a option) -> 'a option val to_list : t -> Elt.t list val to_array : t -> Elt.t array val invariants : t -> bool val mem : t -> Elt.t -> bool val add : t -> Elt.t -> t val remove : t -> Elt.t -> t val union : t -> t -> t val inter : t -> t -> t val diff : t -> t -> t val symmetric_diff : t -> t -> (Elt.t, Elt.t) Core_kernel.Either.t Core_kernel.Sequence.t val compare_direct : t -> t -> int val equal : t -> t -> bool val subset : t -> t -> bool val fold_until : t -> init:'b -> f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b val iter2 : t -> t -> f:([ `Both of Elt.t * Elt.t | `Left of Elt.t | `Right of Elt.t ] -> unit) -> unit val filter : t -> f:(Elt.t -> bool) -> t val partition_tf : t -> f:(Elt.t -> bool) -> t * t val elements : t -> Elt.t list val min_elt : t -> Elt.t option val min_elt_exn : t -> Elt.t val max_elt : t -> Elt.t option val max_elt_exn : t -> Elt.t val choose : t -> Elt.t option val choose_exn : t -> Elt.t val split : t -> Elt.t -> t * bool * t val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list val find_exn : t -> f:(Elt.t -> bool) -> Elt.t val find_index : t -> int -> Elt.t option val remove_index : t -> int -> t val to_tree : t -> Tree.t val to_sequence : ?in_:[ `Decreasing_order | `Decreasing_order_less_than_or_equal_to of Elt.t | `Increasing_order | `Increasing_order_greater_than_or_equal_to of Elt.t ] -> t -> Elt.t Core_kernel.Sequence.t val to_map : t -> f:(Elt.t -> 'data) -> (Elt.t, 'data, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t val empty : t val singleton : Elt.t -> t val union_list : t list -> t val of_list : Elt.t list -> t val of_array : Elt.t array -> t val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t val of_sorted_array_unchecked : Elt.t array -> t val stable_dedup_list : Elt.t list -> Elt.t list val map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t val filter_map : ('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t option) -> t val of_tree : Tree.t -> t val of_map_keys : (Elt.t, 'a, Elt.comparator_witness) Core_kernel.Core_set_intf.Map.t -> t val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end val hash : t -> int val compare : t -> t -> int val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t module Table : sig type key = t type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t type 'b t = (key, 'b) hashtbl type ('a, 'b) t_ = 'b t type 'a key_ = key val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t val create : ('a key_, 'b, unit -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_report_all_dups : ('a key_, 'b, ('a key_ * 'b) list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_or_error : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_exn : ('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val of_alist_multi : ('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_mapped : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> [ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ]) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_or_error : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_ Core_kernel.Or_error.t) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val create_with_key_exn : ('a key_, 'r, get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val group : ('a key_, 'b, get_key:('r -> 'a key_) -> get_data:('r -> 'b) -> combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_) Core_kernel.Core_hashtbl_intf.create_options_without_hashable val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t val clear : ('a, 'b) t_ -> unit val copy : ('a, 'b) t_ -> ('a, 'b) t_ val invariant : ('a, 'b) t_ -> unit val fold : ('a, 'b) t_ -> init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c val iter : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit val existsi : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool val for_alli : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool val length : ('a, 'b) t_ -> int val is_empty : ('a, 'b) t_ -> bool val mem : ('a, 'b) t_ -> 'a key_ -> bool val remove : ('a, 'b) t_ -> 'a key_ -> unit val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val add : ('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ] val add_or_error : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit Core_kernel.Or_error.t val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit val change : ('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit val add_multi : ('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit val map : ('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_map : ('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter_mapi : ('c, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ val filteri : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ val partition_map : ('c, ('d, ('a, 'b) t_ -> f:('b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_mapi : ('c, ('d, ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) -> ('a, 'c) t_ * ('a, 'd) t_) Core_kernel.Core_hashtbl_intf.no_map_options) Core_kernel.Core_hashtbl_intf.no_map_options val partition_tf : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val partitioni_tf : ('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_ val find_or_add : ('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b val find : ('a, 'b) t_ -> 'a key_ -> 'b option val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b val find_and_call : ('a, 'b) t_ -> 'a key_ -> if_found:('b -> 'c) -> if_not_found:('a key_ -> 'c) -> 'c val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit val merge : ('c, ('k, 'a) t_ -> ('k, 'b) t_ -> f:(key:'k key_ -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] -> 'c option) -> ('k, 'c) t_) Core_kernel.Core_hashtbl_intf.no_map_options val merge_into : f:(key:'a key_ -> 'b -> 'c option -> 'c option) -> src:('a, 'b) t_ -> dst:('a, 'c) t_ -> unit val keys : ('a, 'b) t_ -> 'a key_ list val data : ('a, 'b) t_ -> 'b list val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit val filteri_inplace : ('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit val equal : ('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool val similar : ('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list val validate : name:('a key_ -> string) -> 'b Core_kernel.Validate.check -> ('a, 'b) t_ Core_kernel.Validate.check val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit val t_of_sexp : (Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t val sexp_of_t : ('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t end module Hash_set : sig type elt = t type 'a hash_set = 'a Core_kernel.Hash_set.t type t = elt hash_set type 'a t_ = t type 'a elt_ = elt val create : ('a, unit -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val of_list : ('a, 'a elt_ list -> 'a t_) Core_kernel.Hash_set_intf.create_options_without_hashable val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t end module Hash_queue : sig module Key : sig type t = t val hash : t -> int val t_of_sexp : Sexplib.Sexp.t -> t val sexp_of_t : t -> Sexplib.Sexp.t val compare : t -> t -> int end type 'a t val length : 'a t -> int val is_empty : 'a t -> bool val iter : 'a t -> f:('a -> unit) -> unit val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum val exists : 'a t -> f:('a -> bool) -> bool val for_all : 'a t -> f:('a -> bool) -> bool val count : 'a t -> f:('a -> bool) -> int val sum : (module Core_kernel.Commutative_group.S with type t = 'sum) -> 'a t -> f:('a -> 'sum) -> 'sum val find : 'a t -> f:('a -> bool) -> 'a option val find_map : 'a t -> f:('a -> 'b option) -> 'b option val to_list : 'a t -> 'a list val to_array : 'a t -> 'a array val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option val invariant : 'a t -> unit val create : unit -> 'a t val clear : 'a t -> unit val mem : 'a t -> Key.t -> bool val lookup : 'a t -> Key.t -> 'a option val lookup_exn : 'a t -> Key.t -> 'a val enqueue : 'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ] val enqueue_exn : 'a t -> Key.t -> 'a -> unit val first : 'a t -> 'a option val first_with_key : 'a t -> (Key.t * 'a) option val keys : 'a t -> Key.t list val dequeue : 'a t -> 'a option val dequeue_exn : 'a t -> 'a val dequeue_with_key : 'a t -> (Key.t * 'a) option val dequeue_with_key_exn : 'a t -> Key.t * 'a val dequeue_all : 'a t -> f:('a -> unit) -> unit val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ] val remove_exn : 'a t -> Key.t -> unit val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ] val replace_exn : 'a t -> Key.t -> 'a -> unit val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit val foldi : 'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b end val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit val create : ?tid:Bap.Std.tid -> ?name:string -> unit -> Bap.Std.Graphlib.Ir.t val of_sub : Bap.Std.sub Bap.Std.term -> Bap.Std.Graphlib.Ir.t val to_sub : Bap.Std.Graphlib.Ir.t -> Bap.Std.sub Bap.Std.term module Tree : sig type t = node tree val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Frontier : sig type t = node frontier val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Path : sig type t = node path val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Partition : sig type t = node partition val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end module Group : sig type t = node group val to_string : t -> string val str : unit -> t -> string val pps : unit -> t -> string val ppo : out_channel -> t -> unit val pp : Format.formatter -> t -> unit end end end